/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package ig.metrica.ui.escenario;

import ig.finanzas.ManejadorBandas;
import ig.metrica.ModelosDTO;
import ig.metrica.ejb.escenario.EscenariosDTO;
import ig.metrica.escenario.GeneraEscenario;
import ig.metrica.escenario.GeneraEscenarioHome;
import ig.metrica.escenario.GenerarEscenariosUtil;
import ig.util.ClienteHTTP;
import ig.util.ConexionServer;
import ig.util.ejb.IGBean;
import java.util.Collection;
import java.util.Date;
import java.util.Properties;
import javax.naming.Context;
import javax.swing.JOptionPane;

/**
 *
 * @author jsanchez
 */
public class MEscenarios extends Thread {

    private Escenarios panel = null;

    public MEscenarios(Escenarios panel) {
        this.panel = panel;
    }

    @Override
    public void run() {
        super.run();
    }

    public void existeEscenarioEnProceso() throws Exception {
        Collection<EscenariosDTO> lista = this.lookupEscenariosSBbeanBean().findAll();
        for (EscenariosDTO escenariosDTO : lista) {
            if (escenariosDTO.getEstado() != null && (!escenariosDTO.getEstado().equals(2) && !escenariosDTO.getEstado().equals(3))) {
                throw new Exception("Posiblemente el Escenario siguiente está en proceso\nDetalle:" +
                        " \nEscenario: " + escenariosDTO.toString() + "" +
                        " \nUsuario que lo inicio: " + escenariosDTO.login() + "" +
                        " \nFecha Corte: " + escenariosDTO.getFecha().toString() + "" +
                        " \nFecha de Proceso: " + escenariosDTO.getFechaproceso() + "" +
                        " \nHora de Inicio: " + escenariosDTO.getHorainicio()+"\n" +
                        "\nSoluciones:\n" +
                        " -Verifique con "+escenariosDTO.login()+" si esta generando algun Escenario\n" +
                        " -Ejecute el Administrador de Escenarios y Eliminine el Escenario detallado.");
            }
        }
    }

    public Collection cargarModelos() throws Exception {
        try {
            Collection lista = this.lookupModeloSBean().findAll();
            return lista;
        } catch (Exception e) {
            throw new Exception("No se pudo cargas los modelos actuales \n" + e.toString());
        }
    }

    public boolean existeEscenario(String modelo, String nombre) throws Exception {
        Integer ID = this.lookupEsceraio().getEscenario(modelo, nombre);
        if (ID != null) {
            return true;
        } else {
            return false;
        }
    }
    String modelo = null;
    String nombreEscenario = null;

    public void procesar(String _fecha, String nombreEscenario, ModelosDTO modelosDTO, boolean debug, boolean datosActuales,ManejadorBandas bandasLiquidez, ManejadorBandas bandasRiesgo) throws Exception {
        int mAnno = Integer.parseInt(_fecha.trim().substring(6, 10)) - 1900;
        int mMes = Integer.parseInt(_fecha.trim().substring(3, 5)) - 1;
        int mDia = Integer.parseInt(_fecha.trim().substring(0, 2));

        Date fecha = new Date(mAnno, mMes, mDia);
        String ROOT_HTML = acordarVariablesDeProceso(fecha, modelosDTO);
        modelo = modelosDTO.getNombre();
        this.nombreEscenario = nombreEscenario;
        if (nombreEscenario.trim().equals("")) {
            new ServerThread(fecha, modelosDTO.getNombre(), this.lookupEsceraio(), this.panel, debug, datosActuales,bandasLiquidez, bandasRiesgo).start();
        } else {
            new ServerThread(fecha, modelosDTO.getNombre(), nombreEscenario, this.lookupEsceraio(), this.panel, debug, datosActuales,bandasLiquidez, bandasRiesgo).start();
        }
        cargaHtml = new CargaHtml(this, "metrica", ROOT_HTML);
        cargaHtml.start();
    }
    private CargaHtml cargaHtml = null;

    public String getNombreModelo() {
        return modelo;
    }
    DProgresoGuardar dProgreso = null;

    void finalizar() {
        cargaHtml.setSeguir(false);
    }

    void guardar() {
        new HiloAlmacena1().start();
        dProgreso = new DProgresoGuardar(panel.getFrame());
        dProgreso.setVisible(true);
        dProgreso = null;
    }

    public synchronized void pararProceso() throws Exception {
        this.lookupEsceraio().pararEscenario(this.getNombreModelo());
        while (ESTADOESCENARIO == null || ESTADOESCENARIO.equals("PROCESANDO")) {
            try {
                Thread.sleep(3000);
            } catch (Exception e) {
            }
        }
    }
    private String ESTADOESCENARIO = null;

    public void setESTADOESCENARIO(String ESTADOESCENARIO) {
        this.ESTADOESCENARIO = ESTADOESCENARIO;
    }

    void recargarPaginas(String lineas) {
        if (lineas == null || lineas.trim().equals("")) {
            cargaHtml.setTime(1000);
        } else {
            cargaHtml.setTime(10);
            panel.addLinea(lineas);
        }
    }

    void setFin(String string) {
        panel.setFin(string);
    }

    /*void setESTADO_PROCESO(String string) {
    System.out.println(string);
    }*/
    void setNombreEscenario(String substring) {
        panel.setNombreEscenario(substring);
    }

    private String acordarVariablesDeProceso(Date fecha, ModelosDTO modelosDTO) {
        String DIR_HTML = null;
        try {
            DIR_HTML = lookupEsceraio().getDirHTML(fecha, modelosDTO.toString());
        } catch (Exception ex) {
            new Exception("No se pudo sincronizar con el servidor de aplicaciones", ex);
            ex.printStackTrace();
        }
        return DIR_HTML;
    }

    private GeneraEscenario lookupEsceraio() throws Exception {
        try {
            GeneraEscenario generaEscenario = null;
            Properties prop = new Properties();
            prop.put(Context.INITIAL_CONTEXT_FACTORY, IGBean.INITIAL_CONTEXT_FACTORY);
            String Sockec = new ConexionServer().getSocketServer();
            prop.put(Context.PROVIDER_URL, Sockec);

            javax.naming.Context c = new javax.naming.InitialContext(prop);

            Object remote = c.lookup("ig.metrica.escenario.GeneraEscenario");

            GeneraEscenarioHome rv = (GeneraEscenarioHome) javax.rmi.PortableRemoteObject.narrow(remote, GeneraEscenarioHome.class);
            generaEscenario = rv.create();
            return generaEscenario;
        } catch (javax.naming.NamingException ne) {
            throw new Exception(ne);
        } catch (javax.ejb.CreateException ce) {
            throw new Exception(ce);
        } catch (java.rmi.RemoteException re) {
            throw new Exception(re);
        }
    }

    public ig.metrica.ejb.escenario.EscenariosSBbeanRemote lookupEscenariosSBbeanBean() {
        try {

            Properties prop = new Properties();
            prop.put(Context.INITIAL_CONTEXT_FACTORY, IGBean.INITIAL_CONTEXT_FACTORY);
            String Sockec = new ConexionServer().getSocketServer();
            prop.put(Context.PROVIDER_URL, Sockec);

            javax.naming.Context c = new javax.naming.InitialContext(prop);
            Object remote = c.lookup("EscenariosSBbeanBean");
            ig.metrica.ejb.escenario.EscenariosSBbeanRemoteHome rv = (ig.metrica.ejb.escenario.EscenariosSBbeanRemoteHome) javax.rmi.PortableRemoteObject.narrow(remote, ig.metrica.ejb.escenario.EscenariosSBbeanRemoteHome.class);
            return rv.create();

        } catch (javax.naming.NamingException ne) {
//            java.util.logging.Logger.getLogger(getClass().getName()).log(java.util.logging.Level.SEVERE,"exception caught" ,ne);
            throw new RuntimeException(ne);
        } catch (javax.ejb.CreateException ce) {
//            java.util.logging.Logger.getLogger(getClass().getName()).log(java.util.logging.Level.SEVERE,"exception caught" ,ce);
            throw new RuntimeException(ce);
        } catch (java.rmi.RemoteException re) {
//            java.util.logging.Logger.getLogger(getClass().getName()).log(java.util.logging.Level.SEVERE,"exception caught" ,re);
            throw new RuntimeException(re);
        }
    }

    private ig.metrica.ModeloSRemote lookupModeloSBean() throws Exception {
        try {
            ig.metrica.ModeloSRemote modeloSB = null;
            Properties prop = new Properties();
            prop.put(Context.INITIAL_CONTEXT_FACTORY, IGBean.INITIAL_CONTEXT_FACTORY);
            String Sockec = new ConexionServer().getSocketServer();
            prop.put(Context.PROVIDER_URL, Sockec);

            javax.naming.Context c = new javax.naming.InitialContext(prop);
            Object remote = c.lookup("ModeloSBean");
            ig.metrica.ModeloSRemoteHome rv = (ig.metrica.ModeloSRemoteHome) javax.rmi.PortableRemoteObject.narrow(remote, ig.metrica.ModeloSRemoteHome.class);
            modeloSB = rv.create();
            return modeloSB;
        } catch (javax.naming.NamingException ne) {
            throw new Exception(ne);
        } catch (javax.ejb.CreateException ce) {
            throw new Exception(ce);
        } catch (java.rmi.RemoteException re) {
            throw new Exception(re);
        }
    }

    class HiloAlmacena1 extends Thread {

        @Override
        public void run() {
            try {
                
                while (dProgreso == null) {
                }
                panel.addLinea("--Finalizando\n");
                dProgreso.setEscenario(nombreEscenario);
                int i = 1;
                Collection<String> Tablas = GenerarEscenariosUtil.reloadTablasGuardar();
                for (String elem : Tablas) {
                    String msg = (i++) + " de " + Tablas.size() + " - " + elem + "\n";
                    dProgreso.setMensaje(msg);
                    panel.addLinea(msg);
                    lookupEsceraio().grabarEscenario(lookupEsceraio().getEscenario(), elem, false);
                }
                lookupEsceraio().grabarEscenario(lookupEsceraio().getEscenario(), "", true);
                dProgreso.dispose();
                panel.addLinea("--Finalizado");
            } catch (Exception ex) {
                JOptionPane.showMessageDialog(panel, "No se pudo finalizar el escenario\n" + ex.toString(), "Mensaje", JOptionPane.OK_OPTION);
                panel.addLinea("No se pudo finalizar el escenario :" + ex.toString());
                try {
                    dProgreso.dispose();
                } catch (Exception e) {
                }
            }
            try {
                this.finalize();
            } catch (Throwable ex) {
                ex.printStackTrace();
            }

        }
    }
}

class CargaHtml extends Thread {

    private String dir = null;
    private String WEB_ROOT = null;
    private ClienteHTTP clienteHTML = null;
    int i = 0;
    boolean seguir = true;
    long time = 500;
    private MEscenarios modelo = null;
    private boolean reload = true;

    public CargaHtml(MEscenarios modelo, String WEB_ROOT, String dir) {
        this.modelo = modelo;
        this.dir = dir;
        this.WEB_ROOT = WEB_ROOT;
        clienteHTML = new ClienteHTTP();
        clienteHTML.setDir(dir);
    }

    public void setDir(String dir) {
        this.dir = dir;
    }

    public void setSeguir(boolean seguir) {
        this.seguir = seguir;
    }

    public void setTime(long time) {
        this.time = time;
    }

    public void setReload(boolean reload) {
        this.reload = reload;
    }
    private String ESTADOESCENARIO = "";

    @Override
    public void run() {
        while (seguir || (ESTADOESCENARIO.equals("PROCESANDO") || ESTADOESCENARIO.equals(""))) {
            try {
                String lineas = clienteHTML.getHTML(WEB_ROOT + "/" + dir + "/reporte");
                if (/*lineas.trim().contains("PROCESO_INTERRUMPIDO_POR_EL_USUARIO") ||*/lineas.trim().contains("END_PROCESS") || lineas.trim().contains("NOMBRE_ESCENARIO")) {
                    /*if (lineas.trim().contains("PROCESO_INTERRUMPIDO_POR_EL_USUARIO")) {
                    modelo.recargarPaginas(lineas);
                    } else */
                    if (lineas.trim().contains("END_PROCESS")) {
                        ESTADOESCENARIO = "FINALIZADO";
                        modelo.setESTADOESCENARIO(ESTADOESCENARIO);
                        seguir = false;
                        this.finalize();
                    } else if (lineas.trim().contains("NOMBRE_ESCENARIO")) {
                        modelo.setNombreEscenario(lineas.trim().substring(("[" + modelo.getNombreModelo() + "]NOMBRE_ESCENARIO:").length()));
                        ESTADOESCENARIO = "PROCESANDO";
                        modelo.setESTADOESCENARIO(ESTADOESCENARIO);
                    }
                } else if (reload) {
                    modelo.recargarPaginas(lineas);
                } else {
                    this.finalize();
                }
                try {
                    sleep(time);
                } catch (Exception e) {
                }
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            } catch (Throwable ex) {
                ex.printStackTrace();
            }
        }
        try {
            this.finalize();
        } catch (Throwable ex) {
            ex.printStackTrace();
        } finally {
            modelo.setFin(null);
        }
    }
}
